/*
 * Copyright 2014 mango.jfaster.org
 *
 * The Mango Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package org.jfaster.mango.reflect;

import org.jfaster.mango.util.Objects;

import javax.annotation.Nullable;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

public final class TypeResolver {

    private final TypeTable typeTable;

    public TypeResolver() {
        this.typeTable = new TypeTable();
    }

    private TypeResolver(TypeTable typeTable) {
        this.typeTable = typeTable;
    }

    static TypeResolver accordingTo(Type type) {
        return new TypeResolver().where(TypeMappingIntrospector.getTypeMappings(type));
    }

    /**
     * Returns a new {@code TypeResolver} with type variables in {@code formal} mapping to types in
     * {@code actual}.
     * <p/>
     * <p>For example, if {@code formal} is a {@code TypeVariable T}, and {@code actual} is {@code
     * String.class}, then {@code new TypeResolver().where(formal, actual)} will {@linkplain
     * #resolveType resolve} {@code ParameterizedType List<T>} to {@code List<String>}, and resolve
     * {@code Map<T, Something>} to {@code Map<String, Something>} etc. Similarly, {@code formal} and
     * {@code actual} can be {@code Map<K, V>} and {@code Map<String, Integer>} respectively, or they
     * can be {@code E[]} and {@code String[]} respectively, or even any arbitrary combination
     * thereof.
     *
     * @param formal The type whose type variables or itself is mapped to other type(s). It's almost
     *               always a bug if {@code formal} isn't a type variable and contains no type variable. Make
     *               sure you are passing the two parameters in the right order.
     * @param actual The type that the formal type variable(s) are mapped to. It can be or contain yet
     *               other type variables, in which case these type variables will be further resolved if
     *               corresponding mappings exist in the current {@code TypeResolver} instance.
     */
    public TypeResolver where(Type formal, Type actual) {
        Map<TypeVariableKey, Type> mappings = new HashMap<TypeVariableKey, Type>();
        populateTypeMappings(mappings, formal, actual);
        return where(mappings);
    }

    /**
     * Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}.
     */
    TypeResolver where(Map<TypeVariableKey, ? extends Type> mappings) {
        return new TypeResolver(typeTable.where(mappings));
    }

    private static void populateTypeMappings(
            final Map<TypeVariableKey, Type> mappings, Type from, final Type to) {
        if (from.equals(to)) {
            return;
        }
        new TypeVisitor() {
            @Override
            void visitTypeVariable(TypeVariable<?> typeVariable) {
                mappings.put(new TypeVariableKey(typeVariable), to);
            }

            @Override
            void visitWildcardType(WildcardType fromWildcardType) {
                WildcardType toWildcardType = expectArgument(WildcardType.class, to);
                Type[] fromUpperBounds = fromWildcardType.getUpperBounds();
                Type[] toUpperBounds = toWildcardType.getUpperBounds();
                Type[] fromLowerBounds = fromWildcardType.getLowerBounds();
                Type[] toLowerBounds = toWildcardType.getLowerBounds();
                if (!(fromUpperBounds.length == toUpperBounds.length
                        && fromLowerBounds.length == toLowerBounds.length)) {
                    throw new IllegalArgumentException(String.format("Incompatible type: " +
                            "%s vs. %s", fromWildcardType, to));
                }
                for (int i = 0; i < fromUpperBounds.length; i++) {
                    populateTypeMappings(mappings, fromUpperBounds[i], toUpperBounds[i]);
                }
                for (int i = 0; i < fromLowerBounds.length; i++) {
                    populateTypeMappings(mappings, fromLowerBounds[i], toLowerBounds[i]);
                }
            }

            @Override
            void visitParameterizedType(ParameterizedType fromParameterizedType) {
                ParameterizedType toParameterizedType = expectArgument(ParameterizedType.class, to);
                if (!fromParameterizedType.getRawType().equals(toParameterizedType.getRawType())) {
                    throw new IllegalArgumentException(String.format( "Inconsistent raw type: %s vs. %s",
                            fromParameterizedType, to));
                }
                Type[] fromArgs = fromParameterizedType.getActualTypeArguments();
                Type[] toArgs = toParameterizedType.getActualTypeArguments();
                if (fromArgs.length != toArgs.length) {
                    throw new IllegalArgumentException(String.format("%s not compatible with %s",
                            fromParameterizedType, toParameterizedType));
                }
                for (int i = 0; i < fromArgs.length; i++) {
                    populateTypeMappings(mappings, fromArgs[i], toArgs[i]);
                }
            }

            @Override
            void visitGenericArrayType(GenericArrayType fromArrayType) {
                Type componentType = Types.getComponentType(to);
                if (componentType == null) {
                    throw new IllegalArgumentException(String.format("%s is not an array type.", to));
                }
                populateTypeMappings(mappings, fromArrayType.getGenericComponentType(), componentType);
            }

            @Override
            void visitClass(Class<?> fromClass) {
                // Can't map from a raw class to anything other than itself.
                // You can't say "assuming String is Integer".
                // And we don't support "assuming String is T"; user has to say "assuming T is String".
                throw new IllegalArgumentException("No type mapping from " + fromClass);
            }
        }.visit(from);
    }

    /**
     * Resolves all type variables in {@code type} and all downstream types and
     * returns a corresponding type with type variables resolved.
     */
    public Type resolveType(Type type) {
        if (type instanceof TypeVariable) {
            return typeTable.resolve((TypeVariable<?>) type);
        } else if (type instanceof ParameterizedType) {
            return resolveParameterizedType((ParameterizedType) type);
        } else if (type instanceof GenericArrayType) {
            return resolveGenericArrayType((GenericArrayType) type);
        } else if (type instanceof WildcardType) {
            return resolveWildcardType((WildcardType) type);
        } else {
            // if Class<?>, no resolution needed, we are done.
            return type;
        }
    }

    private Type[] resolveTypes(Type[] types) {
        Type[] result = new Type[types.length];
        for (int i = 0; i < types.length; i++) {
            result[i] = resolveType(types[i]);
        }
        return result;
    }

    private WildcardType resolveWildcardType(WildcardType type) {
        Type[] lowerBounds = type.getLowerBounds();
        Type[] upperBounds = type.getUpperBounds();
        return new Types.WildcardTypeImpl(
                resolveTypes(lowerBounds), resolveTypes(upperBounds));
    }

    private Type resolveGenericArrayType(GenericArrayType type) {
        Type componentType = type.getGenericComponentType();
        Type resolvedComponentType = resolveType(componentType);
        return Types.newArrayType(resolvedComponentType);
    }

    private ParameterizedType resolveParameterizedType(ParameterizedType type) {
        Type owner = type.getOwnerType();
        Type resolvedOwner = (owner == null) ? null : resolveType(owner);
        Type resolvedRawType = resolveType(type.getRawType());

        Type[] args = type.getActualTypeArguments();
        Type[] resolvedArgs = resolveTypes(args);
        return Types.newParameterizedTypeWithOwner(
                resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs);
    }

    private static <T> T expectArgument(Class<T> type, Object arg) {
        try {
            return type.cast(arg);
        } catch (ClassCastException e) {
            throw new IllegalArgumentException(arg + " is not a " + type.getSimpleName());
        }
    }

    /**
     * A TypeTable maintains mapping from {@link TypeVariable} to types.
     */
    private static class TypeTable {
        private final Map<TypeVariableKey, Type> map;

        TypeTable() {
            this.map = new HashMap<TypeVariableKey, Type>();
        }

        private TypeTable(Map<TypeVariableKey, Type> map) {
            this.map = map;
        }

        /**
         * Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}.
         */
        final TypeTable where(Map<TypeVariableKey, ? extends Type> mappings) {
            Map<TypeVariableKey, Type> newMap = new HashMap<TypeVariableKey, Type>();
            newMap.putAll(map);
            for (Map.Entry<TypeVariableKey, ? extends Type> mapping : mappings.entrySet()) {
                TypeVariableKey variable = mapping.getKey();
                Type type = mapping.getValue();
                if (variable.equalsType(type)) {
                    throw new IllegalArgumentException(String.format("Type variable %s bound to itself", variable));
                }
                newMap.put(variable, type);
            }
            return new TypeTable(newMap);
        }

        final Type resolve(final TypeVariable<?> var) {
            final TypeTable unguarded = this;
            TypeTable guarded = new TypeTable() {
                @Override
                public Type resolveInternal(
                        TypeVariable<?> intermediateVar, TypeTable forDependent) {
                    if (intermediateVar.getGenericDeclaration().equals(var.getGenericDeclaration())) {
                        return intermediateVar;
                    }
                    return unguarded.resolveInternal(intermediateVar, forDependent);
                }
            };
            return resolveInternal(var, guarded);
        }

        /**
         * Resolves {@code var} using the encapsulated type mapping. If it maps to yet another
         * non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
         * doesn't try to resolve any type variable on generic declarations that are already being
         * resolved.
         * <p/>
         * <p>Should only be called and overridden by {@link #resolve(TypeVariable)}.
         */
        Type resolveInternal(TypeVariable<?> var, TypeTable forDependants) {
            Type type = map.get(new TypeVariableKey(var));
            if (type == null) {
                Type[] bounds = var.getBounds();
                if (bounds.length == 0) {
                    return var;
                }
                Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
        /*
         * We'd like to simply create our own TypeVariable with the newly resolved bounds. There's
         * just one problem: Starting with JDK 7u51, the JDK TypeVariable's equals() method doesn't
         * recognize instances of our TypeVariable implementation. This is a problem because users
         * compare TypeVariables from the JDK against TypeVariables returned by TypeResolver. To
         * work with all JDK versions, TypeResolver must return the appropriate TypeVariable
         * implementation in each of the three possible cases:
         *
         * 1. Prior to JDK 7u51, the JDK TypeVariable implementation interoperates with ours.
         * Therefore, we can always create our own TypeVariable.
         *
         * 2. Starting with JDK 7u51, the JDK TypeVariable implementations does not interoperate
         * with ours. Therefore, we have to be careful about whether we create our own TypeVariable:
         *
         * 2a. If the resolved types are identical to the original types, then we can return the
         * original, identical JDK TypeVariable. By doing so, we sidestep the problem entirely.
         *
         * 2b. If the resolved types are different from the original types, things are trickier. The
         * only way to get a TypeVariable instance for the resolved types is to create our own. The
         * created TypeVariable will not interoperate with any JDK TypeVariable. But this is OK: We
         * don't _want_ our new TypeVariable to be equal to the JDK TypeVariable because it has
         * _different bounds_ than the JDK TypeVariable. And it wouldn't make sense for our new
         * TypeVariable to be equal to any _other_ JDK TypeVariable, either, because any other JDK
         * TypeVariable must have a different declaration or name. The only TypeVariable that our
         * new TypeVariable _will_ be equal to is an equivalent TypeVariable that was also created
         * by us. And that equality is guaranteed to hold because it doesn't involve the JDK
         * TypeVariable implementation at all.
         */
                if (Types.NativeTypeVariableEquals.NATIVE_TYPE_VARIABLE_ONLY
                        && Arrays.equals(bounds, resolvedBounds)) {
                    return var;
                }
                return Types.newArtificialTypeVariable(
                        var.getGenericDeclaration(), var.getName(), resolvedBounds);
            }
            // in case the type is yet another type variable.
            return new TypeResolver(forDependants).resolveType(type);
        }
    }

    private static final class TypeMappingIntrospector extends TypeVisitor {

        private static final WildcardCapturer wildcardCapturer = new WildcardCapturer();

        private final Map<TypeVariableKey, Type> mappings = new HashMap<TypeVariableKey, Type>();

        /**
         * Returns type mappings using type parameters and type arguments found in
         * the generic superclass and the super interfaces of {@code contextClass}.
         */
        static Map<TypeVariableKey, Type> getTypeMappings(
                Type contextType) {
            TypeMappingIntrospector introspector = new TypeMappingIntrospector();
            introspector.visit(wildcardCapturer.capture(contextType));


            Map<TypeVariableKey, Type> copyMap = new HashMap<TypeVariableKey, Type>(introspector.mappings);
            return Collections.unmodifiableMap(copyMap);
        }

        @Override
        void visitClass(Class<?> clazz) {
            visit(clazz.getGenericSuperclass());
            visit(clazz.getGenericInterfaces());
        }

        @Override
        void visitParameterizedType(ParameterizedType parameterizedType) {
            Class<?> rawClass = (Class<?>) parameterizedType.getRawType();
            TypeVariable<?>[] vars = rawClass.getTypeParameters();
            Type[] typeArgs = parameterizedType.getActualTypeArguments();
            if (vars.length != typeArgs.length) {
                throw new IllegalStateException();
            }
            for (int i = 0; i < vars.length; i++) {
                map(new TypeVariableKey(vars[i]), typeArgs[i]);
            }
            visit(rawClass);
            visit(parameterizedType.getOwnerType());
        }

        @Override
        void visitTypeVariable(TypeVariable<?> t) {
            visit(t.getBounds());
        }

        @Override
        void visitWildcardType(WildcardType t) {
            visit(t.getUpperBounds());
        }

        private void map(final TypeVariableKey var, final Type arg) {
            if (mappings.containsKey(var)) {
                // Mapping already established
                // This is possible when following both superClass -> enclosingClass
                // and enclosingclass -> superClass paths.
                // Since we follow the path of superclass first, enclosing second,
                // superclass mapping should take precedence.
                return;
            }
            // First, check whether var -> arg forms a cycle
            for (Type t = arg; t != null; t = mappings.get(TypeVariableKey.forLookup(t))) {
                if (var.equalsType(t)) {
                    // cycle detected, remove the entire cycle from the mapping so that
                    // each type variable resolves deterministically to itself.
                    // Otherwise, a F -> T cycle will end up resolving both F and T
                    // nondeterministically to either F or T.
                    for (Type x = arg; x != null; x = mappings.remove(TypeVariableKey.forLookup(x))) {
                    }
                    return;
                }
            }
            mappings.put(var, arg);
        }
    }

    // This is needed when resolving types against a context with wildcards
    // For example:
    // class Holder<T> {
    //   void set(T data) {...}
    // }
    // Holder<List<?>> should *not* resolve the set() method to set(List<?> data).
    // Instead, it should create a capture of the wildcard so that set() rejects any List<T>.
    private static final class WildcardCapturer {

        private final AtomicInteger id = new AtomicInteger();

        Type capture(Type type) {
            if (type instanceof Class) {
                return type;
            }
            if (type instanceof TypeVariable) {
                return type;
            }
            if (type instanceof GenericArrayType) {
                GenericArrayType arrayType = (GenericArrayType) type;
                return Types.newArrayType(capture(arrayType.getGenericComponentType()));
            }
            if (type instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                return Types.newParameterizedTypeWithOwner(
                        captureNullable(parameterizedType.getOwnerType()),
                        (Class<?>) parameterizedType.getRawType(),
                        capture(parameterizedType.getActualTypeArguments()));
            }
            if (type instanceof WildcardType) {
                WildcardType wildcardType = (WildcardType) type;
                Type[] lowerBounds = wildcardType.getLowerBounds();
                if (lowerBounds.length == 0) { // ? extends something changes to capture-of
                    Type[] upperBounds = wildcardType.getUpperBounds();
                    String name = "capture#" + id.incrementAndGet() + "-of ? extends ";
                            //+ Joiner.on('&').join(upperBounds); //TODO
                    return Types.newArtificialTypeVariable(
                            WildcardCapturer.class, name, wildcardType.getUpperBounds());
                } else {
                    // TODO(benyu): handle ? super T somehow.
                    return type;
                }
            }
            throw new AssertionError("must have been one of the known types");
        }

        private Type captureNullable(@Nullable Type type) {
            if (type == null) {
                return null;
            }
            return capture(type);
        }

        private Type[] capture(Type[] types) {
            Type[] result = new Type[types.length];
            for (int i = 0; i < types.length; i++) {
                result[i] = capture(types[i]);
            }
            return result;
        }
    }

    /**
     * Wraps around {@code TypeVariable<?>} to ensure that any two type variables are equal as long as
     * they are declared by the same {@link java.lang.reflect.GenericDeclaration} and have the same
     * name, even if their bounds differ.
     * <p/>
     * <p>While resolving a type variable from a {var -> type} map, we don't care whether the
     * type variable's bound has been partially resolved. As long as the type variable "identity"
     * matches.
     * <p/>
     * <p>On the other hand, if for example we are resolving List<A extends B> to
     * List<A extends String>, we need to compare that <A extends B> is unequal to
     * <A extends String> in order to decide to use the transformed type instead of the original
     * type.
     */
    static final class TypeVariableKey {
        private final TypeVariable<?> var;

        TypeVariableKey(TypeVariable<?> var) {
            this.var = var;
        }

        @Override
        public int hashCode() {
            return Objects.hashCode(var.getGenericDeclaration(), var.getName());
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof TypeVariableKey) {
                TypeVariableKey that = (TypeVariableKey) obj;
                return equalsTypeVariable(that.var);
            } else {
                return false;
            }
        }

        @Override
        public String toString() {
            return var.toString();
        }

        /**
         * Wraps {@code t} in a {@code TypeVariableKey} if it's a type variable.
         */
        static Object forLookup(Type t) {
            if (t instanceof TypeVariable) {
                return new TypeVariableKey((TypeVariable<?>) t);
            } else {
                return null;
            }
        }

        /**
         * Returns true if {@code type} is a {@code TypeVariable} with the same name and declared by
         * the same {@code GenericDeclaration}.
         */
        boolean equalsType(Type type) {
            if (type instanceof TypeVariable) {
                return equalsTypeVariable((TypeVariable<?>) type);
            } else {
                return false;
            }
        }

        private boolean equalsTypeVariable(TypeVariable<?> that) {
            return var.getGenericDeclaration().equals(that.getGenericDeclaration())
                    && var.getName().equals(that.getName());
        }
    }
}
